{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**mxnet60分钟入门Gluon教程，适合做过深度学习的人使用。入门教程地址：  \n",
    "https://beta.mxnet.io/guide/getting-started/crash-course/index.html    \n",
    "mxnet安装方法：pip install mxnet**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 在mxnet中使用ndarray处理数据  \n",
    "ndarray类似numpy,在mxnet下通过ndarray处理数据，ndarry类似与numpy。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pip install -U mxnet 安装mxnet库\n",
    "# 如\n",
    "from mxnet import nd\n",
    "# jupyter 多行输出\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get started  \n",
    "基本操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[1. 2. 3.]\n",
       " [5. 6. 7.]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立2行3列的矩阵\n",
    "nd.array(((1,2,3),(5,6,7)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[1. 1. 1.]\n",
       " [1. 1. 1.]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立2行3列的矩阵，用1填充\n",
    "x = nd.ones((2,3))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[0.09762704 0.18568921 0.43037868]\n",
       " [0.6885315  0.20552671 0.71589124]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立2行3列的矩阵，用随机数填充\n",
    "y = nd.random.uniform(-1,1,(2,3))\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[2. 2. 2.]\n",
       " [2. 2. 2.]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立2行3列的矩阵，用2.0填充\n",
    "x = nd.full((2,3), 2.0)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3), 6, numpy.float32)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看变量x的维度，大小，类型\n",
    "(x.shape, x.size, x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations  \n",
    "运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[0.19525409 0.37137842 0.86075735]\n",
       " [1.377063   0.41105342 1.4317825 ]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对应元素相乘\n",
    "x * y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[1.1025515 1.204048  1.5378398]\n",
       " [1.9907899 1.2281718 2.0460093]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回e的y幂次方\n",
    "y.exp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[1.4273899 3.219899 ]\n",
       " [1.4273899 3.219899 ]]\n",
       "<NDArray 2x2 @cpu(0)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将y转置后进行x,y矩阵乘法\n",
    "nd.dot(x, y.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## indexing  \n",
    "切片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[0.71589124]\n",
       "<NDArray 1 @cpu(0)>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读取第2第3个数的值，nd序号从0开始\n",
    "y[1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[0.18568921 0.43037868]\n",
       " [0.20552671 0.71589124]]\n",
       "<NDArray 2x2 @cpu(0)>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读取第2列到第3列的值\n",
    "y[:,1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[0.09762704 4.         4.        ]\n",
       " [0.6885315  4.         4.        ]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读取第2列到第3列的值，并将赋值为4\n",
    "y[:,1:3] = 4\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting between MXNet NDArray and NumPy  \n",
    "mxnet的ndarry与numpy互相转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, array([[2., 2., 2.],\n",
       "        [2., 2., 2.]], dtype=float32))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将x转换为numpy格式\n",
    "a = x.asnumpy()\n",
    "(type(a), a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[2. 2. 2.]\n",
       " [2. 2. 2.]]\n",
       "<NDArray 2x3 @cpu(0)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将numpy数组转换ndarray格式\n",
    "nd.array(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 通过mxnet的Gluon模块建立网络  \n",
    "Gluon包是MXNet的高级封装接口，易于使用，同时保持了底层API的大部分灵活性。Gluon包为深入学习提供了一个清晰、简洁、简单的API。它使得在不牺牲训练速度的情况下，使得建立和训练深度学习模型更加容易。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mxnet import nd\n",
    "# 载入gluon包\n",
    "from mxnet.gluon import nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create your neural network’s first layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dense(None -> 2, linear)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立输出节点为2的全连接层(dense层，类似keras)\n",
    "layer = nn.Dense(2)\n",
    "layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用默认的方法初始权重\n",
    "layer.initialize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[ 0.0009278  -0.00674768]\n",
       " [-0.02683341  0.00671751]\n",
       " [ 0.00798804  0.02131375]]\n",
       "<NDArray 3x2 @cpu(0)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成3行4列的矩阵\n",
    "x = nd.random.uniform(-1,1,(3,4))\n",
    "# 输入x到layer层\n",
    "layer(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[-0.01631819 -0.00312688  0.0408415   0.04370362]\n",
       " [ 0.00404529 -0.0028032   0.00952624 -0.01501013]]\n",
       "<NDArray 2x4 @cpu(0)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 打印权重数据\n",
    "layer.weight.data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chain layers into a neural network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Conv2D(None -> 6, kernel_size=(5, 5), stride=(1, 1), Activation(relu))\n",
       "  (1): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)\n",
       "  (2): Conv2D(None -> 16, kernel_size=(3, 3), stride=(1, 1), Activation(relu))\n",
       "  (3): MaxPool2D(size=(2, 2), stride=(2, 2), padding=(0, 0), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)\n",
       "  (4): Dense(None -> 120, Activation(relu))\n",
       "  (5): Dense(None -> 84, Activation(relu))\n",
       "  (6): Dense(None -> 10, linear)\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 建立一个Sequential序贯模型\n",
    "# nn.Sequential用法类似与nn.Dense，但都是nn.Block的子类\n",
    "net = nn.Sequential()\n",
    "# Add a sequence of layers.\n",
    "# lenet，用到了卷积层，池化层，全连接层\n",
    "net.add(# Similar to Dense, it is not necessary to specify the input channels\n",
    "        # by the argument `in_channels`, which will be  automatically inferred\n",
    "        # in the first forward pass. Also, we apply a relu activation on the\n",
    "        # output. In addition, we can use a tuple to specify a  non-square\n",
    "        # kernel size, such as `kernel_size=(2,4)`\n",
    "        nn.Conv2D(channels=6, kernel_size=5, activation='relu'),\n",
    "        # One can also use a tuple to specify non-symmetric pool and stride sizes\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        nn.Conv2D(channels=16, kernel_size=3, activation='relu'),\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        # The dense layer will automatically reshape the 4-D output of last\n",
    "        # max pooling layer into the 2-D shape: (x.shape[0], x.size/x.shape[0])\n",
    "        nn.Dense(120, activation=\"relu\"),\n",
    "        nn.Dense(84, activation=\"relu\"),\n",
    "        nn.Dense(10))\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 10)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 初始化网络\n",
    "net.initialize()\n",
    "# Input shape is (batch_size, color_channels, height, width)\n",
    "x = nd.random.uniform(shape=(4,1,28,28))\n",
    "y = net(x)\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6, 1, 5, 5), (84,))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 输出第一层权重的维度以及第6层偏置的维度\n",
    "(net[0].weight.data().shape, net[5].bias.data().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a neural network flexibly  \n",
    "通过nn.Block创建一个更加灵活的神经网络结构，主要有两部分：  \n",
    "+ __ init __ create the layers 创建层  \n",
    "+ forward define the forward function 确定前向传播层函数功能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MixMLP(\n",
       "  (blk): Sequential(\n",
       "    (0): Dense(None -> 3, Activation(relu))\n",
       "    (1): Dense(None -> 4, Activation(relu))\n",
       "  )\n",
       "  (dense): Dense(None -> 5, linear)\n",
       ")"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MixMLP(nn.Block):\n",
    "    def __init__(self, **kwargs):\n",
    "        # Run `nn.Block`'s init method\n",
    "        super(MixMLP, self).__init__(**kwargs)\n",
    "        self.blk = nn.Sequential()\n",
    "        self.blk.add(nn.Dense(3, activation='relu'),\n",
    "                     nn.Dense(4, activation='relu'))\n",
    "        self.dense = nn.Dense(5)\n",
    "    def forward(self, x):\n",
    "        y = nd.relu(self.blk(x))\n",
    "        print(y)\n",
    "        return self.dense(y)\n",
    "\n",
    "net = MixMLP()\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "<NDArray 2x4 @cpu(0)>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\n",
       "[[0. 0. 0. 0. 0.]\n",
       " [0. 0. 0. 0. 0.]]\n",
       "<NDArray 2x5 @cpu(0)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 初始化网络\n",
    "net.initialize()\n",
    "x = nd.random.uniform(shape=(2,2))\n",
    "net(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[[-0.02634858  0.05334064  0.02748809]\n",
       " [ 0.06669661 -0.01711474  0.01647211]\n",
       " [-0.04485548  0.00594983 -0.06654498]\n",
       " [ 0.04964591 -0.06058505  0.03413684]]\n",
       "<NDArray 4x3 @cpu(0)>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 打印权重\n",
    "net.blk[1].weight.data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 训练神经网络  \n",
    "本节我们将导入数据，建立网络模型，并进行训练。最后通过matplotlib进行绘图和基准测试benchmarking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment the following line if matplotlib is not installed.\n",
    "# !pip install matplotlib\n",
    "\n",
    "from mxnet import nd, gluon, init, autograd\n",
    "from mxnet.gluon import nn\n",
    "from mxnet.gluon.data.vision import datasets, transforms\n",
    "from IPython import display\n",
    "import matplotlib.pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get data  \n",
    "手写数字mnist数据集是深度学习中最常用的数据集之一。但要得到99%的准确度太简单了。这里我们使用了一个类似但稍微复杂的数据集，叫做FashionMNIST。目标不再是对数字进行分类，而是对服装类型进行分类。数据集可以通过Gluon的data.vision.datases模块自动下载。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('X shape: ', (28, 28, 1), 'X dtype', numpy.uint8, 'y:', 2)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist_train = datasets.FashionMNIST(train=True)\n",
    "X, y = mnist_train[0]\n",
    "#FashioniMMIST图像为28*28d的灰度图，y为类别标签\n",
    "('X shape: ', X.shape, 'X dtype', X.dtype, 'y:', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAABmCAYAAAAu58sfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJztnXd4XMXV/7+zRbta9WbLXe4dG4xpBkzvCTVAgNDeEBJKSONNfwNpJCH5QRISIAkJEEIJBELohGLAYIxtMK64y022mtWllbbc3x9n5p6Rdq1mlZU5n+fx46u5Ze+dOzP33jnfc45yHAeCIAiCIAiCIAhCz/AM9gkIgiAIgiAIgiAMReRjShAEQRAEQRAEoRfIx5QgCIIgCIIgCEIvkI8pQRAEQRAEQRCEXiAfU4IgCIIgCIIgCL1APqYEQRAEQRAEQRB6waB/TCmlFiml7tnf30IiSqkTlFKOUqqwk20cpdRFB/g7B3yMgxGl1NVKqcYD3UbonO60P2mjjFLqeaXUg4N9HoIgDG2UUmuUUrf1YPsu30kEATh43/EH/WNK+HSjlCrRg/Dhg30ufcwTACZ0tdHBOrAM4HWNAPBcF+ciH7ZCyiETAX2P1KkwFJB2evDhG+wTSEWUUj4AMUcyGgu9xHGcFgAt+1tv2tjAndHBieM4eztbr5TyD9S5pDJKqTTHcdoG+zwEQRAE4WDjgCxTevb5PqXUb5VSNfrfnUopj15fqpT6VpJ9uj1jrZTKU0o9pI/dopR6TSk1U6/L0WWf6bDPaUqpiFJqmP57lFLqcescX1BKTba2v02bta9WSm0B0Aogo/c10+n1nKGUekefxz6l1CtKqenWemOpuVAp9V+lVLNSap1S6tROjhlQSj2jlPrQXHOSbTqtg04o1ts2K6W2K6Wu6HDc2fqetOjreVAplWOt9yilfqiU2qmUalVKrVZKnWsdYpv+f5m+7kXdOKcBQSl1vFLqfaVUo1KqTim1VCk1y1p/sm43TUqpN5VS46117awh+2ljTwJYCOBGfe2OUqpk4K6wf9BSsy6vS/ffvyulKpRSYaXUVqXU1zpslq+UelLX8dYk7c+d4bP6zueVUm8opVoAXA/gbwAyrHO5re+vemBRSoV0X2tUSpUrpb7XYX2pbnN/VUrVAviHLu9qLByjlHpW9+VmpdQnSqlLrfX/p8eBVqXUXqXUwwN20QOMIr6plNqkr3eXUuoOva6rcW++UupVpVSVUqpeKbVYKXW0tb5ULz6p22QpPgVInfac/T2HlFIFSqnHdB22KKXWKqWu6bDvIqXUH5VSP9f1VqGU+rXS72h6m2G6z7fovn1tknP4hlJqlR6Hdyul/qKUyh2I6x8MpJ32Oz61/++GK5RSy5RSDbq9PqmUGmXvrJQ6Wym1QdF7w9tKqUvVIL8/9YXM73J9nKNBLy5fAtDxhehAeBDAkQDOBXAEgGYALyul0h3HqQPwvD6Hjuf0quM4FUqpEIA3AYRBL3hHA9gD4DW9zjAewGUAPgdgjt6+P8gAcLe+lhMA1AF4TimV1mG7nwH4nT6XZQAeV0pldjyYUiobwMsA8gGc4DhORZJtulsHybgdwH8AzAXwJwAPKy3J0/u+DKBRX8/5AI4B8Fdr/1sA3Arg2wBmA3gGwNNKqbl6/RH6/zNAkq0LujifAUGR5ehZAItB9+BIAL8FW5MCAL4L4FpQfeYCuK+Lw3ZsY/8DYAnoZX+E/rezL69jkLgF3buun4LaxDkApoHqcneHbf4PdB/mgKSTf1VKjevi9+8A8EcAM0Bt92ugccOcy697fEWpx68BnArgQgAnAzgUwPEdtvkGgE8AHA7ge90cB/4IIATgRAAzQXVXCwBKqQsBfAvADQAmg+7bB/1zeSnBzwH8ENSeZoL67c5ujntZAP4O4Di9zUoALyr2KZmv/78O1Cbn49OB1GkP6OI5FATwIagfztTl9yulTu5wmMsBREH1eROoT19irX8QwCQApwA4D8CVAEo6HCOu95sJeoYdAeD3B36FKYu00/6ls++GNAA/ArX3cwAUAnjM7KiUGgvgaQAv6G1+B+BXA3Xi+8VxnF7/A7AIwEYAyir7AYBderkUwLeS7HNPd/4GPbAdAMdb63NAHyBf1H+fC3pRytJ/pwOoB/B5/fe1ADZ1OEcvgGoAF+u/bwMQATD8QOqjl3WYARoYj9V/l+hrvt7aZpQuM9ucoP+eDmAF6IUx2OG4DoCLulsH+zk3B8CfO5S9BuARvXydvhdZ1npzbpP037sB/F+SNvBIh+s9fKDrvov7kq/Pa2GSdVfrdVOtsssBtAHwWNs0WuuTtrGO7f9g+ded69Lt9m9dtL87rL99uq9f0WEb085NW/pmkvvV2N1zT/V/ADJBls3LO5TVAnhQ/10K4LkO+3VnLFwF4Ef7+d1vANgAwD/YdTBAdRwG8OUk67oc95Lso0Afrknb7qfhn9Rpr+psv8+h/Wz/OIC/WH8vArCkwzb/NdsAmKKPv8BaPw70TnJbJ79zhh6DzPPO3KvCwa6zPqhzaaf9W7+L0Ml3Q5Ltp+n6Gq3/vgPA+g77f09vUzJY19UXlqn3HX01miUARmmLyYEyHTQjssQUOGSNWg2adQaAF0EvWOfrvz8LarzP6r/ngSwCDdpM3gjqDHkAJlq/tctxnPI+OOdOUUpNVEo9qpTaopSqB1AO+kIf22HTVdZymf6/o4TvVQC7AFzgOE5nlrTu1kEyliT529T9dACrHMdpsNa/B7pnM3QbGAng3Q7HWGwdIyVxHGcfaMbuFUVSqG8opcZYm7Q6jrPB+rsMgB9kodofA9LGUhEtQWnU/17SxfcCuFgp9bGWnixMsqvbDxzHiQKoRGI/6MjyvjnrlGUiaPbOHhcbQeOiTcd66M448FsAP1BKLVFK/VQpNc/a/0nQbPg2pdQDSqnPKaUCfXZVqcUMkPX59STrOh33AFc6db9SaqNSqg5AA6jddhznP01InfaQzp5DSimvUur7Wn5XrfvzBej8XQKgZ5UZQ807lmthdhxnO/idA/q3TlLkdrBLKdUAsgykASjukwtNLaSd9j/7/W5QSh2mSHa6Xbc18xwz9TcNwLIO+y8dgHPulP4OQBEHfdjY9MQhvOO+NvR57zgRpdSTIMvAw/r/px3HadbbeUBm1kuTHGOftdzUg/M6EJ4DWWuu1/9HAawDDUw2EbPgOI6jlAISZZnPA7gYJJX6qJPf7G4d9BQFfR+S4OxnubOylMJxnGuUUneDZuE+C+BnSqnz9Opox831/51NUAxUG0tFzgL3/RYAcBznJS3ZOxMkVXtBKfWk4zi27j/S/jBw0LU8+WCv587GRZuO9dDlOOA4zgNKqVdA9+sUAO8ppe5wHOc2x3F2KqWmgu7VKQB+A+BHSqkjHcc52Oq8szruzrj3EIDhAL4OshK2gl7OOo7znyakTntBJ8+huQC+CZJVrwZJz36OxMmmzsbQLscSPUa/AODPINl1NYDDQNKrg7HupZ0OHgrAKyAF1BcAVIBkfu+A66+zezBo9IVl6kil3/Q1RwEocxynHjSLPMKsUEoFQV+V3WUdWFdpjpEN+nhYZ233CICTlVIzQAPOI9a6D0F64CrHcTZ3+HcgHxI9RilVAJrZ+LnjOK85jrMepK/t7UftD0F+Oq9ZPkjJOJA6OCrJ3+v18joAc5RSWdb6Y0D3bL1uA2UAju1wjGPB989EGPN2cR6DguM4HzuO80vHcU4Amaev6uOfaEOKXvsB0u66HMfZbrW53VZ5leM4f3cc52qQD9lV/WDtONjqeDPoBcntm0qpDACz9rsH0a1xwHGcXY7j/MlxnItBL09fstaFHcd5wXGcr4O0/jMBLOizK0sd1oFegjr6n5h1+x339N/HAvi9rqu1oNnpEe0PgwgOrnbZFVKnvWQ/z6FjQVLevzuOsxLAFpBsryesB9Wx67ejfVJGWtscDnqR/brjOEscx9nYYf3BhrTT/ifpdwPo+VQI4HuO47ztOM4nSJwcWI9EP7MjMMj0xcfUSAB3K6WmKoqqdSuAu/S6NwBcriih20yQk163LVOO42wCyfXuV0odp5SaDfpQqgfwqLXduwC267Iq/buGf4CkdM8qpRYqpcYrio7zG9W9aHZ9SY0+v+uUUpO0rOk+JFo5uo3jON8HcD/og2rOfjY7kDq4QCl1nVJqslLqu6AB5m7ruE2goBSzlVLH63N52nGczXqbOwF8S1GEtSlKqR+DHDN/o9dXgCwVpyulhisrKs5gouvoF0qpY5RS45RSJwI4BO0/4vuCUgBHKIpEV6isKEtDnFJ0cV1KqR8rpc7TbWs6SKKy1XGc1n44l6BS6lR9Ll0FXUlptKTvAQC/1NdkxtauHs5djgOKIiydoZSaoCdozoBu84oiUX5R9/XxAK4BvRRs6p8rHTy0jOe3AO5QSl2jSJ59hFLqK+jeuLcRwBVKqRlKqfkgX5aOoelLQZOAxUqpvIG4rsFE6rTndPEc2gi61mOVUtMA3AOS8XYbLVV/GfSOdbTu8w+ifVqPTaB3xa/p8/k8+jbIWEoh7XRA2N93ww7Qh+xN+hl0NoCfdNj3PgATFbkGTFVKXQBSegGDabE6EIcr0AzJfaBOXAv6WPgNAK9enw0yBdeBJG03oAcBKPTfeSCzaQ2og78GYGaSc/kxqCJ/k2TdcFBksQrQjdoGevko1OtvA7DmQOqiB3V2EoA1IAfHNQBOB5nnr9brS5AkIAPaO9qfgA7OniCnvCoAczpu35062M+5OqDoPy/rut8B4KoO28wGmbBb9D16EECOtd4DsqDtBA0oqwGc1+EYX9THjgFYNBD3oRv3aThIF75b19cOUMQYP5IENOh4Tzpus782BppJXALy+xtUB8o+rr8urwvA9wGs1dvsA/k/Tk/W5q2yUlhBbTr0i6R9R6+7V/cPB504Vg+Vf6DANQ/rsaNC97Hn0T4AxbeS7NfVWPh70MtTGKQseBzAKL3uPH1Pa0EvFMsAnDPYddGPdewB8B0AW/XYtRPAz/S6rsa9OSAdfwvIYvAF0Hh/m7XNZ3RdRwCUDvb1Sp2m3j90/hzK0+sadH/+FSga5yJr/0XoEAhI1+vzHX7jP7ped4Kexx3r9av6HFr0PboY1riOgygAhbTTfq/bRej8u+ESXW9hkC/f6bptnWAd4xzQR2sYJAG8Rm8z4EHkzD+lT6xXKMoJtMZxnJt6fRBBEARBEARBEIQeopS6BWRQyXMcJz4Y59DfASgEQRAEQRAEQRAOGKXUjSBlRCXI3+qHIFXGoHxIAfIxJQiCIAiCIAjC0GASKLdUASg90H0gy9SgcUAyP0EQBEEQBEEQhE8rB0vkMEEQBEEQBEEQhAFFPqYEQRAEQRAEQRB6Qac+U2kq4ASRMVDnMqRoQE2V4zhFPd1P6nT/DHqdmhxyXUhfI8X0W8pydXT0tIRjpaGz18d17u7AzqY+OYfu0ts6BQamrbaN5OMHsyi9VLiBc/b6G6kePGFOxRbN5FR1pl5VZswtM1WXtovr0Gntu9RVYTShzWlVXW+ZyKD1/8x0Xm6kFDIqjesxlpHmLntqumij/US/9X/V3Vtl2gtvb5b6VQ5vjxk6HVu3f6+L7QZ9TO0hbROD7rKplniU53wDgYi73NpK7Te4h8ucNl7uL4ZanQ4FBqVO7WGhk27k5HBawtFjKwEAzXEeLwOK2lzMSvPnU/w82l5Fl5W2p5vjqj1eHcC4czC009ZxXPeBaqsuGluSbN3/dFannX5MBZGBI1WyJNDCa85T23uzn9Tp/hnsOlUBeonv6sV717XHAAD8jVwW0++qMSsltddK09c0lgbXyTcvTTyghwdh5aVlJ2LtfAAfWL2tU6Ab9WrOy87HG48l33Y/bP/K0e7ylIXbAACb3pzglhUvoXoIbahwy/YdPdJdbhhLv+0/Zp9b1halOhz33bBbFtu4Zf8n0cOH11Ln9S632R+D1f/jh851lz2LVwIAfMWj3bLao0a5y5lPJmmjA0B/9X/TrxG37q0nyQdWTLddr9UfdduI2y/pPWzj+0X3e2Wdi0qjlzQnkiSPe5Jz7mqsGuwxtafs/NUsd9njofvVVMMTAVPH73GXN2wdAQCYcftetyy6c1d/n+KQq9OhwGDUqfLx669jxoYkfTt8/BHu8p2//wMA4MOWErdscoDaX22MP0CKfPXu8pcfuAEAMOZn73XvvPz8odbuPaCHDJl22sn7zcYfzneXJz/IY7B6d2X7ffezf1/TWZ2KzE8QBEEQBEEQBKEXSGh0QdB0Nsu7+ZFD3eU/HPUAAGBdmGfzn9xJ6yfnVrpl3yj+r7tcEcsEANz+8mfcsswzttKCNRvm9NWs90DgzgR1ntrBN34cACDrkQa3bF3lcABA8A2eWVq9bixtP6XZLWs8nJZfPvRfbtmpay52l5u2ksU9T/GsVMuuLADApi9mu2WxYCEAYORbfF4Z/1ra4TrQ5zLL/sY3ocRdzniY6tdn6UurF9QAALafzbP7w35Alr8/T3vELbvgwW+5y5lP0v8F7+a5ZR8smQoAmPit9/vozAcQM+tsW3aSlHkyaWY5Vs8m52T90TeGLHrffut5t+y6ZVcCACJVXM/jp7IVZUJWNQBgx1Hctk2/tzOjOFGySHmzue3Gk41L8aHRPl0s63uy2f9ndn0AAIhgiVtWFqVrnOJn6V+jw3WxSxuwZ57FdX7maZfST6z5xC0zFghTt8KnHN0Wu9sevn7Xo+7yJ61kDb3zFX6Oj5lJlqntW4a5Zd5stqJsuOEeAMCpS69zy/yvrdjv7x2INWoo4tHKgXiYlSRV15NiJWMLj88tw9n2EzrqEFp4f5VbNtj9XCxTgiAIgiAIgiAIvUAsU4KgiS8k61Lp9Tzr+8XZ7wIATlFvu2V/3XssAGBkep1btnc3zeLXNLDD5CuZrP9/o4Jm9ucX7XDLLt1Ks1Off/Urbtnkh2nmVb33MZ9YqlpJzGyzNdNsZtS3/mWcW/aN2eRjNMrPfk0fZ9H6P1cd55aNeomOVzmXZ5r3ldDM1JIwB6UYm1XjLs86nGb/bYffFWljAAC3TGDfptseuhwA0HQln8MFt5Ou/ZVZbAVI2brugLewAABwyYuL3bJsL83sbW3lGdKHbz4DADDmNZ7Rv/VzLwAANkR4u7ZsNo+U30w+gRPTPnTLnr7obgDAuRlfdcumfOWDA7yKQUSbg5SX/RNitXUJm3knjQcAbLtihFuWeXgVAODGjy9zy74yi8YH4z8BAP+t4/7/n9VzAAAFz7F1tmY93cOp97IFK7q1lM6lnn0uDLYvRVKfr1QmiTVq811HWX9RW3q4bppbUh7RY0lToVs2J5t9ohpiZLG6Jo+tWQV/ovqvPIaPLBYpoR26LXoy2Mep7Drqn7HjeQx4+fD7AQD/rD/ELYvpqBXxbG5T20tJHaEyuMwp5+fV4420/jv3PeyWbW2jsffFytlu2dqdNMZM+0G1WxYt1e8LA+wbNJAks7y3nUH3YdT569yySsu/uuwCeleYZAklXH9TsUwJgiAIgiAIgiAMHeRjShAEQRAEQRAEoRf0iczvQEI5tpzLYSeN33TmyjI+XohM+aqVjxuewGHet36OzH1jX+RjBp8bwvITYUDZ9gs2HX/vPApyEI5zfPOqKAUzqGjNdcuKgyTBOS5ro1t22LGlAICGOEvUxvjZXL86nYJVrK7hsN4tMZILfnnBm25Zw1HU3v+xlCUwU65fRgupZupPJt35zkwAwC2z2Dn/kR1HAgBaIlyvTUtJunPBeWynf7aGtnNGsCNqvJX69203/w+XpXE9NIykIaz2EDbtZ22ksjtPOt0taxlD61sqM92yDSMoCEbpE5PdspJL2KE1ldn+JZKNzgtyPT9cQ2056GHn59u+StISjxUkZHeEJKleK1DFHec85i5ne6j+32yY7pY9U3cYAOBHJ/7bLXsM3JaHGiZceryJc794i+i5svtybg/1s+i5M3wkh+Yv30tjga+K2/O9bccDAApzOHhF2Y4C/r0wzVtWNfM4EppA48i6/2W5Jbx0DuOf4HtjnNXtZ6sd1nko0HIeP+enfnctAODK3Cfdsrhun6dkrHfL0nT7fDdY4pZNSStPOHaTw3VxbO4mAMAnK1iWue4mGpPUko8hCLu+RxrQW77AY1mx7yMAQNjhPv1aM0U48VsS8rerSIa67cy/uGV/qCVZeWOMA6UszOAAKMta6DjlkRy3LFNLsi8avtwt+/YYGmM+eYnH1afm0b7xZg5cY963h3KginZh6bUsz1nA6Tsay9MS9hn+Lsv7m05IXB9vGZzcUwaxTAmCIAiCIAiCIPSCPpne6uoL2TiOnXwdz0Kfmr0GABB2eHb/sxn09T31AXbIH76cZgV2nsnH2/bZP7nLK7TFasvJbK26+H5yXhv/7y+5ZVNuEGuVkMjVZ73hLq9uopDHrZZlKsNHzpFNUXYoHR6gGeX1YZ5BOiJESWFPTSt1y35Sfoq7nOunWZNRBbVuWVUrWUlWN3CI9fXVNEv9+SM4cerKyZMAALFNW7t/YQOIHZ47UkizTP+4/WwuC5ElKe8Tnl3zj6NZ59ceYQtcpp4AbLQMHr5KuhezbudgCC+sYqfddF0lBcs49HKrNgg0LmPH9cIdZMmrOpKPHY3TPldN57p+J0hWGztMayoSOIqsnh6whXJikGY2Iw7XxbPVFFSlvCXLLZufT3kHYw7PpS3fN9Zdzk6ja5+excEUzOxsib/KLXMWnAXASqCYquhgDcqy7NoWKcOev1DDaSi1rELa+lRhBUEoeUk/k6y8lvFS7cy+nC3TOINntAPVdE/sRN+NOl2Ct5XPy99A96T6Jp6FzQ2SVSf4PD/DBjsMcE85+ydsfT9Sj5Wrw2PcsrfCZLE7LI3bV7Nu2rY1qjbOAX5CHhqbVzSXuGVbW+g9wFYN+P9A92HVYQd0CcJBwkWXUH6MDA8HPni/kZ6xIa+lgNLvAYV+DhozK4dUU3fXlLhlVZGshO0+aWPLqEdbWHOs32uO0/tEM9jCsq2Bnv3HZm5wyzbceS4AYPKN/IxyolYC8aGKSrTjlFrpOyb8M/GbIr6KrX15WZMSj2nUOoOk4BHLlCAIgiAIgiAIQi+QjylBEARBEARBEIRe0OderPHjSFby/OMsxfu4jRzoMxRLEjZFyBy/13LKu6+WJDZ/vIz3vbn1egDA1Cnb3bKfVnEuijwfyTVG+VkW8bZW6Kz87G/dssxzyax65sXXumUpL0/pS1SSvCQ9MIHuu5akmsP+u9Mti+7clXjsQTa1dpeKG8gJdbj/abesOkJSnQnplW7Zf8oox8TIDM4/4feQbKQqwsEMyqLUdksjLDctbcx3l2NxmrfI8LOpP0fLqfLTWHI0Jpt+pzHGssJN/0OBEiZ8JzVlftVHF7vLp8xZDQB4d/sctyw8ma459wrO8VTsp2tvi/MQVPnXEgDAhDGcS+az88hpvDLKMrVxY1gKFB9N7eyuKU+4ZSvDLFkz/PyV8wAAU6fsdsumZVJ+n4h1DnuvJS3QsD++l3CMVOKbU18DADRbzveHBKhvGodnABibTnVemMb6stV1pKOMWzK/mTmc6yim59gOSee+boJV+K0xfM8CklyNfPdArmQAiGm5XVqi03LZtzghkQ9UV46fZX4YRm03cznnpIlk0HgWT+NxzQnRb1TPth+pLPMzVZ25m48dDZL0LzzFDrhC/T4/gyWxbTfpMYNjjcBJwTE1GSbA1DlZ/Cxe1DwFQHs56rsNVPY2+NluZKvZHnYs397GcsvtYZJl2lJXI6n6oIn7wIW55OS/+LIb3bLsR60ENcJBjy1FHx+gsf3deg40My+zFABQF2MZqQkSYcv+jdx5QhoHpHm0dD4A4Krx3KZsCbVXB1cx0j4ACOggQXYfyPFRny9t43eI0ZP4d1yGSN/vjGSuQU4J93PfG/rdfD/vkRWVlIPOcym7CWQ9TvWvfHy/BjJIh1imBEEQBEEQBEEQekHPLVNdWBzOu59mTJ+1HHbNbFLQmtUck0YO1CMti1JllL4290Y5fOzqr9wDAFjWyr+1sW24u5ymZwqqo2wlMLMCL+kQwABwWJBmu1/651/dsrNGJfFINdd3EHz9Azig6/EWcmjf47UD5MdbOXyl11imkh07xeuvdi7NDNlhpNO9tDzOcoIeFiKn0voIhz1t1MEoCi1vctPm7FmsE4vYkdSUL66a6JZtrCKH0/kjdyScn0dx/QWn1iWsTyVyrmVL0iGZtFx0ETvjLq0uAQDcOu5lt+yxKppRsmeVt59P1/nRpnFuWXkzWaTmFHC6hIXDN7nLy/bRtt/fdr5btmEzWV5UhOeKxs0ky8uYDA4A8vROasuOw2Na5t7EcO+pyEWZFBxic4TPd2+Mxs8JAXbYL/JRsBS7nddHqS0HPDweH5O12V3O9ZKl9O1GthIYZ+yLczkIQnQ+3+OURjs72+GFDQsvWeEuV7WR9Wmrj+u0qpraX+Nstig3ltBjM1DJ7avVS+3YYwWTQJSX2/LomHuP5dVOgO5JWpDvQ1sxHdNOIzA6i9qsXdtOayuGAjvPoXoZ7mWLXLGP+rk9Kx8D1dX2Fn5v2BKm8XFsgFNMNFjhp9M8icE3jOVgenpZQlnVOWwBzH60p1ciDGV2ns9RjfK99NyOxLn9GYu7x0oXYUKdhzxs3Ygo2mdDKweYuKyElFe2pT9mBVgwY29dhK1exjJlh1M3ljA7hPoVY+m9699FM/nYlaycGWokC5wTO9G8h8cTt/fyPbL3yVhL9VbDjygY7YoKsgVQLFOCIAiCIAiCIAgpjnxMCYIgCIIgCIIg9IKuZX4dZWJJ5Fub72InsONCdwMA/lPPcrBZ6bsS9lnTQjl9hvnr3TJj9t8XYWffX1ZriaAlU7GlgVtbSQowOo2lAGVa3mfLXZ5voNw0p2Su4/N+hIJlTLriIz6xFJenJeBhMyicRDNpUrop/dv5Z0tO2UhNpfrrLJUZuZnyI0V3sVN/skAXrqnWMn27uRIGqb7ziqnd2VKTuJZ7vVrLJvWoDhwxNoPb3J4wmeEXlXGug+GZJB04Mr/ULXu7ktebY6f7uB37vSQ/aYqyY3xLVOe1CXPAhfH55BjeZe6OAAAgAElEQVSfqsIe+5pWNVK/vrSQnXFzfORYese2s9yy2Xkkw3lh8Ty37A/n/A0A0Gbdk1vevBxAe5nf3xcd5y5PnkVjy8Yd3FbTd1IdZu7ktpUxk8z9Z+Stdss+2EOBKo4aWeqWXfNrCmTxo6f5vFIFTxa3ibdaSDIy0RoLb/n31QCAZy+6yy3brYMghB2WjU3PIMljUPF9MzIrADgyQDK/76znflC1h9r8jacvdstOLqFcPiy6TE2Ul/qwkyQ9y2m53B6+9uKVtF06y/yKRpHEzsj9ACBQSe1zzOs8Fm4/i3KktIxhKYq/mh+vo9+g9ld1CEtQGudoJ/Qwb+cPUVnFVpZYL1xAEsw1IzjQS3QP5wBLZb694EUAQHmMx34jI22Ic14ZI622ZdJGWprr5XputZzLDV5LmlXoo3HYDhCwW7sN/Gb+P92yP2BKTy9FGMJEjkqUJM/M5PcWExzCluoZKV44ntjmsjwsGd2nXUyyvFzmtSRrJnhSO7mgfsbZxz4lcy0A4E+VC92yfN2eq87id4m8h4auzC9Zfqnyw0my59nS/XfBgrV0b7ZfmLiPEx6cNyWxTAmCIAiCIAiCIPSCri1TxnJgLCDxRAftZ86/213+RAeHKPTxTICxQgUs61KysJP7omSRsjNJx5M4BppAFQDg106odthJs+1yKzxqTZRmcj/0cdjkLSfRTPhZBSe5ZbHqfe2vF0h6zSlDV+dmLEXJrmc/17jtFxQGfVr+NrdsXRnNil4+Y5lbtjSHrH2wDI8qSfjhVHSWPmoEhdq3Z4ZMQAnbMT/bR+20yQpVvq+V2tLkfA5UMS+HjtdsbTcixFbX0noKkx7w8rEnF9AMU4aPZ6zaYr6E7YYFqT+s7+7FDRBqHlkuwjEO6rC1gWbU12WOdstMvy6v49n9HWvJ8pOxk+dz7tp+KgBgcxmHhs39mO5P1Qy2Vt908qvu8rPfPYXO5Qy2rAS0sSZUznW48b0SAMDOc7kW/3c6Hce2Tr7WyNaYVKNtPs+mZ3jeAgDkePi6Jz9M92HLuWzVKPHTeLYyzPfDWPa9VvCP6hgH8IloC/fwTB6Ha2rpmEHL8myP5ymNJ3HOML6QVAmbW7mPmpDo3jorXD/IqlHwAZc1nU71smk8j3WhbDpOrJTbeHwcz1Rvu5DacVo+B61J+4TqXFlDeGg+jSmeLA4TPCVIVqhXPsdh3If/bmhYpi7KIuvlWy3ssD/KR+0vorhOPXomf3Qap08wjvi2BTXTmv03Y3erlR7ABLay91kfJgXFtwvYhvqHXl2NMFS5f97f3eWn9lEoc/NsB4AjMrYAANa0jHHLzLul33ofMGk0Qh5+p1nWPB4AMDuLX4Qa4hxYwlixbMuVadsmHDoA1GpLbWWYx+KGEB2n+lAeq/Me2v91pjrJAkI0zqC6nHJ/4vPEiSV/vw0tp/etUTdnJqxr9xsDGFBOLFOCIAiCIAiCIAi9QD6mBEEQBEEQBEEQekG380yZIAKOJQer+hLJwfZG17plJqdUkSXzq9Hx9UcFWA5k5FCNlizK5JOwTaS2Q6DBlvyZ3FW2zM84U9uSAUNDjJ1e39ZW1+bHWDYYOE3vk8rSvp5gHP6s60kW67/2C0e7y7+7iHJx3bT0MrcspgNQPL6RHfPHrmXnbUNnkr6mC490l3NWkBN8tDQxx9JAMCVEMhm/pbGZECCnZRPUBABGpFGb3dTCAQ7yA2Sab7YCR1RFSN5jS1RN3ioAyA2SbKc2zO2vsY3arAlEAQAlWdT+7Bwqw/xG5sf7pgKl51K/iZfzMBJpIunNK74ZbtnFxSQNfXI3B6rJ3UB91Gvlj4v+nOp4nJelZOWH0/8b/znVLVudy8vqKpJX/eKQ59yy7NOpY//gF9fydvpnbszd4pb9o4GkR8ZBGOB8YUYGBgCet6wANYNIuJAlqRlaxlToZfljfNUnAIB9lmRvWlqis7I7plrjqC11DHnodzaUcZsftoIq0H+pJStMpwA/a8CyzJQknhiYp+wY6kuFPpb5XXcsSSefKuXgSc1h6uP7ZnM9D8ugvhyu5v7YXEfL/lEs2/H7uV+HdfvzWTms4jOoX8e28P06bBg5xZ+Q+4lbZhzcG8bzdfCdST1UgJ/Fpn3aAU7ytdypIsb9LqKlevZ4bNpkU5zH2WZruU4/y80YDQAjtYRwpJefQznexPxi3imU7y+2cUvCOuHgY1MrB28xbWx3mPOZ1gbpHXW4n3M67mojab4d4MTITDOsYBImJ6Tddu0AFCaASr0VcMW07fFW4LSlTRRkYvWuUW7ZaYUUMO30BSvdsiHXYrvITTtlrA4U935ioLr9ESund7VhIT5eOJveR2L1PKYrHbBmIPJNiWVKEARBEARBEAShF3TbMpXsy+6Grz8DAGh2eCbKONttb+VM5pk+miUyjugAMD5AM6bHZHAIU3emykpsXqxnCoq9PGNQb1muMrQjYJNlmTLnYwJfAOzoZzJdA8DHLeMAAD+cyLPav5lxIQAgtm6jW6b8NBs2kNmUu02yr367LImFzVik2k4/3C377v+xg+atq3UdhHm22ldDTeXCI3mG5KJtywEA5795o1s240dk8ak+nuu+NZe+2WdezmHpq08dXOd144RvZn0BIKSoLVVFuMxYQe2Z+8IAOZHXenimaUsjtfeTR7CVdnMzW7jydbjp0n35btmIHJpBMWHTASBLO8W2xHgG1jjAeqdyeNTYhs1dXmN/M/FeClDyya0lbtl1p7wJADg8tNUtu6/sBADAiKnc1/92HrW3S+681S3bfhbNIl176ptu2ZPbyELU1Mz9++ZDFrnL5v4UeNmx38xCZl68xy373xI65u2VbHV4Yh1ZWWOVPJ6YmAqTmvh4qZIsoTWL28k4beGoijUlbGeHhW6O73+It63+dvv26Dk2//qQW5b1+HsAgNidXBtmbPaNmuOWRXdzCPtUpmUU1V9djJ9Jp2eRpT0yjuvihV0UkGTOUdyeX1tJVtdh7/J2NTNoedwRnI5j82aeDc/cpIMlFHJbO+tUsti+E+RASS0xEw6c72tZhGbQ1XB2YE9lPCVjrL+WAmjf1obrUPWbrBl/r6Jna7GnFh2x26YdJj03nZbbrAAU61ppVr8gne9XXYzbsaFmHllTsw8Wy5R55tuhp02qlCTWgL1f42Amw5ZznXoWr0zYtk/owjrRX3jmTAcAFPvZ0vt6mMr2NLMiqTmbni92kIipQXp+mFQ7AFDRRvvYY+x7u0oAAOMms5XJvN8CnJaiMcZ931ixsq0Q65v0+0JBLj97VjTQsc/O/9gtuxf8HpAqGLVTstDndsoe8+7Z+DlWKf1q/L0AgB/jsCTHZTVGsvfvoBWoa8/ZNC5nP/Z+wnZ2+/Noy3k83LfjqVimBEEQBEEQBEEQeoF8TAmCIAiCIAiCIPSCrmV+HeK0+8awfKvIR1K4rW3DEnZrteQlJn/PpADnxni2mkx6P/34M7xTnH7rtHkc2OC/68kk6w+yOa+t1sop1UwSgFAJO50tHE2m+xNzOKfM+vBIOucABwgwEi87J0Xr78j05zuFTysl5X0G22Te3Zj6Rx0CAPjuHzhhwdc/vthdbmmi+vXW8D3MnE6yuEND292yFxvoOHcs+JdbdtJ75ET4SN1st+zfu0kG9P628W7ZxKbBdeo/JkiO3s83cjCDAi2tsfNMGXO8Xfb2XnJePnY4S0lWNlO/WNQw3S1rinI7rQqTnGjGMO4DhVr6t6uZHWEL/FRWZvUfE6wlWsCSJEs0MWhE99C1TPoGX9NbOkjG4imfdcuMk/fn1nKel1ItXQqcxXKJb098HQD3VQC4fcZ/ALTvox+HOVfcq3vJtH8ep7HBX+6hMaV5FPeD8lH0e8vmsmRoAvYvaUkVaZ9Ny3C+6yZIxK17jrG2oDo6LI3lC8t1TjSv4itqs2RTyYhr5+nWgsTADXbAiyIvjblNc9lhOpCCMj8nlngdOWNIomgHNDBysvNzPnTLHnrrOADA4maW6HgzaSyoPoT7aHwYSYR3VnNf9oR4zIgF6X5Fcll2XdZCuWYib7Ik/r059Ey6qfh1t6xO50icNYplq5yFKvUIj8lJKPO0C3ZCyyU6WAQAbIlQHjM731mDlkUVW0EBKqwckzXabWBcGuf7m5ZGY1HIGiDrojQm7YqyfKpxDM0j89GGEMkkfUbO7yTK+pvPZ0nVSbctBgA8/gnXxZFX87N4+XUkg3aWJQaX6oqKm2gsyjiHnwdlFdQfVpx4j1t2xbGXAACi23f2+Dd6SlMJuY6cHeIx8QkP1ZGd9zA4hsZO210k20O9zM4pFfLSeFFrSUePHUPvAXbePTuoUUgHq7CPY6R/9ljs033E5+G+UhehPjDGx8HUvLnUv2K13C8GGzuYWXcoP4Lb7r9rTVCzxKduV+/e9REelwuup3fTyGOd79/X8j6DWKYEQRAEQRAEQRB6QdeWqQ5Wjo03s3OpCRlpO9aZr/AcH8+dmRCm9uzyezvJSpG7ih3MdHRpVM/i2U+nhU4xbY0VLr2Azyk2gr72o1H+wt/RTA6DwTwrfKX+6rVnFMys5NpWtra9rmfCzyo4iX+jWs8KtHOiRP+gf8OEogesr/4kTpyu45+1nSeLZ0XiDWSJ85XwbP6t/3iE/l9/kVvW0sgzMr4yWg5OZ2fgO2ZSsJGlTRPdsvoo3ZN1jeyAviFMJoLV9Wxd2FlKM6/FY61Q9Udoy9UHPZ8B6wt26dlK26HZr9vzsppxbtn8PJrtsB1TDymg2Xc7cMToDKqrIzLZWrXLCr1qZpuqw9y269uo/jL9PGO1uIrqd3I2O7Caftaaz/eIe0Nqkizk8MZmdsj/7XunAgBK2KiJ+795PADgrBFr3LIfrj0XQPu69r1uhbSdQW1+rVVf4ROpzRc+yXX90jEz9VKi5aRdH4rrfuXh3+vprFt/YYIm2LzwySx3eRJohjldsbXlk1bqj/asaDJCVqjfj1ppju2Os3iK74Gv0XgdsWa+s/RMbN04HsMTNQqDT7LZyYWjKYCLHRTJUGRZoXPG0exv2lOWE/oCqoMxh/AMfHUjPVeMVR8AgiH+3egs2icryM/AD9+fTGXWrfnrsQ8CaB9kybT9BQUcdOY18BifatRMCSSUea0HZtgxoaR5Bj5NKwByPTwex/VcbzhupQSw2rHXF9fH4/Vr2+i5MzrEKTdC3jZ9PKZ5RKK1MmWwn/NJUpu472RJrFCtZ853l8uuorr63txn3LJHvnIOAGDiGrYKLfr7ZHd58u9LAQB7vzjNLYuvoeANZbeyFfz3X74PQPt3umUtZGm8a8XJbtnEP9O5Xv4NViDFqvrfImVoy6T6e7yB++/EEFkyqwqsQFNIfJfNSDJmGqWKbek37dhYkIH24frNe6b9rrGvjX/bkK3fmUuy+T3JWF7s1AKR2RSwxvNOaqTsAADfOPouKL2cvw9M927L5rrK3UD/jzt0t1tWpesichqrhKpmUZ1ZmZPQlsPHKVijn9Mt/Nw372XrzzvCLWsaTu/RVtR6dzn/b0u6cWXdRyxTgiAIgiAIgiAIvUA+pgRBEARBEARBEHpBt/NMGe6+4G/ucrXJzG6ZRo2cLpLEybk0UuQuTx1Gjufrj2fzZTRC++T4WVI1XEvDWorZlJ9rZZGfmEcm22icvwvHhfa1Oz8AKPST9KfVkgwYaYtt2n0/TMf+5K4St2zyldrsOhD5EfRvJJUWdfH7Jh+WkfYBgHc4CW+Of46DcfxuN5nhq3azo7C/mpvCpKNJ2vbVMewE/XELyQTt+1ocIAlMzPomPzRUCgB4bMM8t8zTRPtMzOE8DCvOHA4AGPtBp5fUp5i6AIDpaXTv98Ysp1Gdc6YoyM65JiN6leVQaoJRJGvjdh4zW8ZijmnntmiNUZ2HfCwHMvK+dEt2NcJPkoGG0fx7KSvz6yQIyisbODjHgpkUjGLdh1yW/3NyQv/jlSe4ZafMIInJuzs5eEnraDvoCv03MsCyinsP+wcA4JqGa92yeJhknTl+lsAZ+ZcTS5TQOCmoAsocxUF2TC4oVc46iNKfHA0AiGOFW9asHarzfdymIzovT8ySTgYVt7dlLSQj+XKulSvstM8BAH5exdtdk0edt/ZwLktFmV8y5maQDOyDBs7xlOU6inM/O3sc5Y17dsRxvLOfGkd+kGU7Ef38CTdz+/JZz6n8TNq2uoFlhcEq2qduGm93Qjod+4E6rkm/dpi3Ay0ghWV+bbmJZXbeLNO17q/iOr2l6G0AwKYIP5OMvM+W8dmSP9OOjwtxTsj/t5fkw+tbWGZ+WjZJyd8Pc6AU7wi+dymHPXYmkfL5JpQAAPaeylF3vJ+ltnHt+BfdsnseIon0Y5dyXXhBwVXso2acwVKprOVUv6Me4XyJa+po/9+Pvs8tK42QdP83f2FXgZG/plx0k8EBXAyJVzEwNI2kPvZKDcuht9XTc+a0Yn4nCmrJsh1EItnz3QRSMbnfAH4PsqXSdl41884Z83CZkf7ZbTvdS7/97hqWXZ42lyTv89L4XJpH0JieKBQcPFqm0vvc1Ze94pbtbaW+XGlJGrNPJemkHRzOyCkX/4qf4UYm+XTZoW7Z9BzO4bd0FrliNDSwtDJTBwE65Puck8vcr2Fp/E78QU0JAKCVP2X6BLFMCYIgCIIgCIIg9IJuW6acBRQy0wv+otyogw2MDbDFwXyFj7TCnhrnZ/tr/Wuj/wsAiI3m2dFKHfa00gp/+pkCCl9c7OUwkNVxnt2r1dYEe5bVOLMGrVmGDIdmDWrBX7L7jCXCx1+tZlZ208l/ccvOSpKZ+YDoEGTCOL3rP9qts9cnc4pPZsFquohDoX7+xzRT9da+KW7ZR+tLAADBMp4VmX8GO/1fNexdAMDr9TPdskwv3UN79mVbC1kaT85Z55Y9WnEUAMC/jGdOIyPpmj7YwUEwvIMQ2zs8m50jX9HBEGzH6FwdCnVsOjuAmsATm1qGu2UvbqBZri/MWprwG6VtbH3NsiysSyv0TEoL25ROGEMO5XvDXFdHZJE14MNGDoLhWv5SIR56V3RiPZ1Xwk7hZxbQbHHtJeluWfX9+prbeB4zw0ft7sjRHJL/i4e95S4vCFLd2GGPf1VxIgBgeDHPdI3XTr3VscQ50qTBXlKQ88evcpf9So8dw9hJ+tq5FPb4ozY2qxX6yJplj73dpTzGQYSqbyDLwhzLsT+sx9zTZvEsdmmPf2VwmBEgB+h3anlcNE7eOR7uo6/uJkf8xon8LDl3Lj2TNjdwX88LUl1V+3gWNiPAY2VxBt2H7ACPCZvn6HsS4fa3LdKoz4XvV0AZS3iPhSSDQiQzcQwo9nL//M5OCkawppID0nx32DsAgIY4jwf5eh+7zLZMhXV97IhycIGiNNrHfvaP0cf5pJUtNLNGUph5tpcNEB3Dmsc7t9mEzyFn+uHf4YA+N4ygIFnXvnCdWzbtFmojz2zmNjkK7yUe0JMkLYJ1Dlsuone6a19d5JZ9reB9AMBVx17qlpmw5iO7+g39PuNJ53sYD7cm/G5/YYIfzM7kgAfLyug9JOTlsdO8M+6xzKrT0ymgQRiWNVSnLLEt/dtbdICtAL+j5vm4ZcWSjL3mvaIhxvUyK53Syhw3ewOfQwa10ycbC9yylnxqQ6lkmUpfTee+uZkt6uaZYwfrMMHhfrbnTLdsdA7VW0ObpbLYQu9bvlpuS1sL+dgTSkjZFo1x3T69nNRQxx3C9WesffY9WLOK3jMmgwMI9QVimRIEQRAEQRAEQegF8jElCIIgCIIgCILQC7qtG9hxC5lB7Xj3Jv9FjZWrw8jAyi1H0hwdX3+P5bT3XmQSgPaOYSZ4RY0Vr39Haz4AoCXGjr3ZVg4r45ybaeUBMlLDHC9vZ2dg73iutqnVBNNYYUmNdn6f8iuM+VkSk3Zv6CzIhNkkybpkTvHxheygt+cWup5vzeC8EvdvIyff8gq+H2mVdNunn7zJLbul+DV3+fEakgkW+tmUbbLIeyyT7YJs2t/klgKA5e+TbCY+zpJqjWpI2HfqKWSKrbst8Zr6i2YriIk3SaIwzhfB7cHIRwNW7pmFE+m6bQdVs7593iqugxl55Dy51cfm+n1t1M631ebzSWiVhjFPA8CaJnKcDhcOBZ3f/rFzRf15O7XLkJ+lUC1FNLeTPZzlEuflkjPztS+zpGVxHuc6izbrISzK80JF79N9qTyO63BYhm7LSaQl7WS2KcwHx3I7Ob2BZNfTRle4Zd9YSsE6Hmvg/mjkK21JnKn3R5GWBi5vtfKCzX4CAHDHxEOsLSfp/1swFPCE+LmSpfPjtMb5EZir+/Db/ChB8zvUIbOPYtn6sx9T3ect4/FkyhU0nnm8PEiH/Nz+Vu3SwQ+28TmYQD/bXy1xy9YdQ5KhAksWZ/I02lL2VCaakdiftkR43BuVTvLbQyexZLQyRtdmy/lr41RXTXF+9tvPkJE6MM++GAuexgRJzmvL0ct0bskdrXwO07JoPF4x0PPJneSISsbPf0dBH26+80a37I57ya1iMlhm3m3BXBfSumgp3ZO/nrrQLct4/VUAwMR/sSxqw+E9+4148+AE/GgroHOx3/+KsqhvNVtJjIyk1M4n6dWhUkwQHwBoNcF7rHYzLt0ODEPY78Tm3dQONmECXUwOcJ0a95Y2a0xa20jjRlEuvydHslNvHIhVUb87MYffKf9TReNkeQu7MWwvpz6Yl8MyyIom6r/VtVberzDVbzTHakvWM35bGY2Tw4t4vPBnU59fvGmSW3bp7OUAgCtyOdLZExUndPu6eoJYpgRBEARBEARBEHqBfEwJgiAIgiAIgiD0gm7L/P4x/wEAwHvNHAPfmNxtk3osScgxE4XIjsRjIn3YZaPTyFRocvsAbGK1j2vLq4yp1pZU1egoffZ55WvJn/17xlRr58nyanOwyaMAAH+8lkztd/zMlrgcON48HYUojc/JaabzdMIcacY7jM5l30KOhudcQabli8dyZLMP6koAALcv+Yxb5vFp87Z1W4zp+9JiNn2ubh3tLudoGaUdAcVEbCy27s1z1WTGfWMV5wpSBWS+zshh6U9bG91/ZwubviedSRHAPjx0Np/Yh0+hP4n7uBJOD5E86q0wS0+NzMc2s5uoUHabM9H+4lalmjqz80xtaeQ2VBAgmUNBkM3bUV2/+yo5euWucSTlsiWqx2eRfOu/nvldXmMqs/lJjpyWXkntcvuplpx1Bi1nW/t8+ZEvAwA8IZb3pG9lqVRgH5Vn7OXj7Juu70uE2++6DyhP1SQ/R2o0eabaRclMwfxSBjt/nKF1EkeZ9Oj2aEd9S1PdEwDZEZcMFVZU1bOzqd/bUrnBku70FjWO8wwF9TjfFrdyt+lIa49XH+WW+fQltosWu5vGa8ebKHmPRrju030s8/NsonorWskNbNtkkrzELVncr7edDgD44tjFbpkZCzKs51lK40lsS5styejV+SSXz/Jw29waobZmy7HMMz/bkl5VtVp5+vSz3EQLBvg9YGZgl1tmJN1e69h86wZwPjkUhJpJkWDrJ5KkyXodQd4aktfuPZafST/YQpHHiu5d4pZ5Z04FADiK258y8sFWq414Eq/NCdH7UjzI7VTF+H7F/VpetYQjh97w4tUAgK0X3e+W3bSMXAE2f4klVZXz6d5YQfKQZFhBTF/z8Df3cOGWxO36An8enYwt6SvJ0pFdI/w+srSZpOPtc7kR9rtnsjyqpn9WRLITygCW9Nn5TJNFuH6igp7vwwIs8TXR7+x3VBOhMJUwz9LamPV80PXmt/r5ESWlAIBwjNtfU4TuzXHTuBG8GJgBAPBYY0leiOt0116ql717rXxfOnqvY43VS6tLAAA3FLCLTsau/qk/sUwJgiAIgiAIgiD0gk4tU05WCNEjKXb7vADl1nipgZ3zW/QUQ9jD0yvGgS9sHdrkg7C/1jnOPn9xbwlTHHk78IEdrz8Z5pj2TMGwNJrhaR8Yo7XdbwDAqdmUW2l5dIJbZpwFyyKcu8JYx0zmcTpQp6e1fzLTET+Mgka88gSlYL5020nu6rhDzrbNUXbGOySHZtkCnlK3bFkNzVjds+IEt8xppTpQQZ4JcJI4Las4lf1117Fu2aUjl7nLkwLknGvP+H3QRDM3d60+2S2LVOm24OMZP0cfu7GS695XS/c/vYrPxQRs8IQHbrY1yk0NMT3D1GQ5l5q8OWfnrXTLnq4iT9uGKG83PYucRj1WEIuKNnKytAOhhKyZ6aYo3Vc7CINZPm76Rt5Hzz7bM7TrwjSj3otUQSlFw3zu/+mF1EezXmPLSuYuuubs6+vdss2Tqd7vOeIxt+ynm892l3fvJktewXie5SzxUvtfu6LELfvCaWTBXfI4B2zBCp0fycozhRTOM+UJcgOOh6mdVc7hskVhGodt52izHE8yb+ZBcjOcCVaRZllZX22h/tx2NFuhfa+vAACoAPcNp9Walk4xIgU8Jj1ce0TC+r0xuu7Xt7IF1aSNml7IgT4aF5CVzrbclzVSgJ9AkMezpggHTig5lhz7d83imdQ5w6nNLq3i2f3tG8iCkzvezlND44QdiME3msaE6C7On5MqqGjiM8cez4JJrKV7o1R/JX62DBR4qA5slYid38cEjrIDBBgrwkgrEFClXm+P1/nuewU/5/ud5jCc5fTOkVtPz9PwWG4PjePpGZJdyv3OdzudX+VXOEeWIRa0LCa62/UgzgzvG+V6McZPZxZbZyc9RnV51v2XuGW7TyOratNlvK8bF8x6xplbbd/yqM5Dlr2T72t/WaZGFlBfbbQsUya4025LlfLhPspBefvEZ92y1WHOS2kw1k1/FxZ/W6GS66W2Zr+PNsRp3C7ycj8/KncbAGBlA6uE1u2m8eCKEWyZ7M09HiieLJvnLl87hvKVVkY5AMX6JgqOFPDy90FdG/Xjp963lDdBqufZE9nCbI+njs4v5U/nd6y6JjrO3BE8JprgF081zMwo6bYAABkvSURBVHLLCtbQGNLX9qkh/nomCIIgCIIgCIIwOMjHlCAIgiAIgiAIQi/oVOYXyVbYeTKZ1h6oI3OjnYMn2xdOuh8ARCwnfhOb3zazh7SXoh0kolw78O1p45xIRr5n72s7khr5QGs8MYa/Lbk6N5PygBzzzllu2bP7yJS98ap73bJvl1NQBa8lgTkhl/b9xdWcvwU/RK+IpntQPYtMvN8rp4AW6ytZ6uTTEiW/la/kP/soSENzA5uqDf4gm5O9GVSXkTaue1NrHo/l2JtDpRvXszn59g3snO3LoeNEWy17cpiWvdlsVs0aRXKsNB+bvL36d9qivG9DJrWZxgBLkuqN5m53ecI19Re2LMKQ7eE20qzbbLUlsZybtRMA8NY+DrwS0U7r09LL3LLqCAU4qLNypJ2Sv85dfreO9rdzLgS8dO+KgixduefDEwAAf17wkFu2uHGqPv/UczwFAFiO0G4elSScMvUTd3mSDgAy4ytskv/mP64FAIxO43vy6/kUlGR1mNvqhByWAmUHaNsvjX7bLSttI/lIyfHVbtmre6bR9paztVlS1vmnaA0DAJxYoiyvpZjP2EhPIkl0ILYkzZsk556NCVrRZI3hJqhFWiXLUtyjxLqd5WZQqR/Pzy5TV9G4lS/GR3UZi3FZdDppl3Y38jOpdgmN1/7DOPdUbnris7A+bEmDtdxoQwWPs8uaSKrtz2VpZLSN7p19v8Ja+r2njWVJkXGU/0qloMzPSUvsRbbz/V7tpF5sSfHyrbxahuo4yaJsiWBZK8vycnR0kGIfB0Xarvt+pSX9y9XvGHb+Sjuf0GAQ20i6Nj8rvOHfz7YAULS4k5UDhN3Li9cO2mn0CPOMrbfeW1t18AOf1a52V1HfKprMbTIjSZCISJJX5mYtvzXvnVTG7S8Yp/Icb2LAnuo4n9eiapIXH5q70y17N0Zy0KDiY6dyurmdldw/g2MTA2+YXJ4B69thVzXVvTeHrzE9RHU/PMhBl5bWcAA2n37v9afx+++wbBpDMnz8TXHiMOpg89O3umUvLeNxtC8Ry5QgCIIgCIIgCEIv6NQy5Q1FUXAozSAflU7OccZxDgAq2siSNCnE1gXj0G8HL6jSDmj2jKn5WrWtR8P9ZOmwg1KYUOa2w1+7EKd6LrnQx1+w5hztcJhvtZAz4Rtn3OWWfXkcBWD490VsibgwlwIx2DML3ys9HwAw4WHOVs15nntGLAjUTqfzN6E5Gxv5ep1a7WRnTe456XTtoTwr3KafvsgjMa7TcEtax13doJ5xazuvtnoFR7Gjf2Mdz5CY/bPyeCbl/PEUKjVgOVa+vEeHr7Tin/qNZS3dtlbR+n1xnlJp0bM5sSThnvsLa2IScW1BsZ3wS6PkVLutlYOUmFmncSEOqW2CZ7xWM8M6Hs1LtMTYSbLVmtk34UHtMKEmAEVlmNufwZ6ZLvRTHXlSNzZCt3hj81R32T+Z6v3pnXPdsuKjydK3roLDKP+ygUJFHzlsu1t2QeGH7vKj5RSi9+NmnrUqbaH7WNqQ75Zl+rW1NYctDElnkoyVqhML26CRJG67py1xmtKeSTWO0OFO573bYwJQ2E7U9XpMVqVlCds78RSsqyS0ZXFd1engBfbYtTicGIwgN5cscVWreEwo2EL3oWoqj9vTdICK3RU862nGaACo1U7WgXIeE/LX033aeyyfQ0EJWbvWtLDz+8g0KnuvigMl+fdQGOBUHBKctMR2aj/n87UaoC2JtbQixpb7YV4a9+yxsF0ACv2ctx3czey//fweo1UwYwM8htvvJ8LBi0lPsLmBg12MyaC+Myq91i3zraNn+YTjeZx8qZGey3aqHjNuVEW4zZmUPlVWO/RbVirTfu02aVRYn8/e7JZtr6Hx54QCNld6dXCvDa2sioqFUjd/R8Y7HGQjchg9R2yLXa6f+uf4QKVbNmw69XNb9VYboZe1zfV83xr2cv2GimhctlVRk7Kr9O/xqGi+GypjdsKV/kEsU4IgCIIgCIIgCL1APqYEQRAEQRAEQRB6Qecyv90KOT8k09s5N94EALhoDkts7iz+CAAwbfEX3DJnA5lGV1zDcroflR8DAMjzs2zMBJSwA0eYnFEj0tj8apxu41YW6rC1T0SRKdGWBhqzrH1sQ3MS5+x7J3Oej7x3SRq06SGWJBX+aUnCPr1F+ePwDaPrvDB/OQDAP5XNth9Vk4NyWSmbN3376Draqvh6jLrH8VkO9frS4rbMwqvX+y0pXpYOfJDJzuTzijme//8WvwIAyLKCVlyz6fMA2jts5wbpOlqj3Iwy/CSfMLkDAKC6WsvYLEWSyVEGZ+AcgS3VHWrjdG1hh+t0qp+kOrUB1gNuDpOzedwKUmCkf3OzuM7WNlIeENvEPDHIuWlMfrM0L8uATB/YF2bT+FfnvQGA864ALCmId9pbB5FuSuImFrNpP6KlD3tLC9yyv532FwDASEuye8ZbNwMAMkewLOfrb37eXR41loJMjExnKYap17J9XIc3zaI8Uy/Uc241c9aOff6pKO/rhFFvcb00X04yElueF0+SnMzITjz7CURhclLZEti6GLXRWH194g5J5IepSCurPlHVSmNSY4SlNy/VzEnYp6GJnitpk/i6a7S8PS+Hx0/j9Oy1cu61WeOicaReO5IlL5VBWh8sZulavf69Lc1FbpkJllDXys+4/O6rNgeeLpqDea7UxflZbAKcjPLVJmy/v4ApE9Iq9b58HJMfMtfDknivHrtj9juEk8oVKPQVeQF651y/j4N8mQAU90951S17zqF31IjDsrHOAvrYbdKMt7aczWs5W5hcf552+9Cx49bzpkn3fTsAW04WteN8Kx+Vk5G6AX9GvMnP+Mm3kvtP0KqXTaD7UGDJdU/PIKnjdssPozRC49/MTJb27cznAdwEFNnRyNJsIyHM9FouRhEa5+usXLL9hVimBEEQBEEQBEEQekHnc91Wxu4p11DRKmv1WTMuBgCMW7faLdt8N4UbDyie+Slv1TN5lmUqWQZpY11qtjK9JwthmmymwD6emXWyHdqyQvSFf8XH17hlw8Chmg01C8iZsBB9Z42ySdvagvGXUi1+/5ovAgDm3/CRu35+0Q4AQMkYtgAaC9vqBg6ru7uJZi9aIlzPWQH6IjdOlwBQEKAZjVHBxBk/ux7/+dHh7vK2n1AY6eArfF6eKIXrjFx0pFt27k8oW/hzFTyjm6YDUNiO3bl5dA6tEW5uxjLlLbCnixNOsU+JZvA55Xvp2u2wuml65qjN4fM0zqWrmtghPF2H2h2dxqG3wyG6nu1hvp4iH89mN6RR247GOcR3SM9mm/DeADAtsAcAsKWNHd7dPjAUjCadBHDYVMbXtHsVhYUu3smzdd8cfREAoNkKKZ31IdXbkpHj3bInTv2ju3zlw7cAAJ4dxfUe3EXjx4hl3A9+e/mJAICp+/ieufabIRLaO1mgB98bK9zlHRGy8tljoQkm0VU49FiSeLteqw9fkk1h/p/HgsSdlTUn56RuXbaMiySU1Yb5GfFBiw5iYtVFWpoezywrfdtEtnoYskyoX6vOWsM8NjfpwDTZRTwjGyugessM8kxqRRU9K30e+3lG41FJDgdQ2KPVFMENCaeSUqxto7rKtcJC2xYpQ7GXxsqwNfbW6wATfisotz3L3aTfE7Ktd4SRfgrWURHjoD4eRVZBOw2LtyvzmXBQUNdGbci8GwH8fjTSy+3Qp7t0uuJ3T/P8tttcGcgSYr+jGquqrQIIWgFOcrVVKc1SDJh3rzwvW2PUTm2VHsOqpOwgtW3bkuoJpO4YG1vPodmMde7dBk4rYwJL2H3RBI+yA3YNS6O6L0njl0L7Xc3ck6ZcflcwijU7EEijDkK3uGKiW5aObT27qG4ililBEARBEARBEIReIB9TgiAIgiAIgiAIvaBrl3aPiWqQaFqMrduYUJa90Tgvs1SiMEDSBuMMBgB1EZJXpHvZhOpTiRIxf5Iy20RvyuPtZCrpCWUm/1VTSxo6onydV4Mrr0lSBwdC/t9ISrjlb4nnsvr4k92yvUfSuY8+ZYdbdsXopQCAuUEuq9Q5Oj5sLnHLTNb3Rxcf45aNfVFnoX5xmVs2BcsTzi+Zqiz7HTaRvlI9EwBQFGTpismZlOVn6UUkSG0olMWBBT5YQabfydVLk/xK/xCzghh81EoO9fmW/GSLdl625Y/GdJ9hOTXmaE1AZZRzF5h6LkrjurCdqZ+qIhnljhp2mJyic9O0WTnAjFSrNMym/lEBkq6ooSDz6ySAw5lT17nLG0aQ5K/mUZY95v+K7kmokPvovun0f9li3u7y5V91l02aiaOnb3HLLl1IbeqbwavcstAKkgA0zWS5RGC7zjSvDo45JTMuxqw5sphDdRlULKuIdzGHZgJU2Ll4dkaHvsP+pAmcJ7Ba939bOreuUgebifFzI1lzDoWoXsKWbNl+jhk8Xn5OmWeRnRelpp7G9ZxQomxw7T7OKzMmSP3/0mEfuGU/nE5S7JHPJ57fYBPczW1lZprO54VSt+yVJsrp88UcltkvbaXxM8vDzw0jDayNhRLKAGC3Hq/DDo8XhwSoT68Il7hlJsfMjbk73bIXmk0wDw70IRx8NEToPo/NqHHLzPtopocDuoy6dyUAoP5r3P7MO2O1JRkN6fcAW/qXpQOn2TlYbal1g85NlUxqvSXC7wujF+mcgEdy/5mQRbL0TS0cQMPnT12Zn837LRT0YW6G9Y5qSfAMZa3ksmK/OwUV1W84SRA5gJ9RuVZgDujXqD0RDvJlglHs2svvXZNF5icIgiAIgiAIgpA6dG2Z6miNsUJEqzSaEXJaeQZz2B/fAwB4f8DfaebL1HbIz/XQDFOTlRW62aHlNicxZGoyB2l7fYY1i2pmZu2v4Ck67HX6+5noSDvH7j62PnWGsUI5UXZMNMu2Y/noN/TCHbzvP1Hc7v/9Q9c2GZ1bgFQg0Ol6c49j5Rzuu05Hma5rt2UTOhIAhcu0a3Yyyjr9vf7A402cZo5YTqNm5shuS+URmjWxnSO3NZPV6NDCUrfspYpZAIBsyyKXlcezV2bWZVpRuVvm007taV6emTZOqpPTebuaKM2ie1uS94GUohNLdoaP6/ULo8gq+6uzT3fLNs+j67xywWK3rDFK7fL5zbPcspPGs5Pr5YV0HDOTBQDrWilQy9SjSt2ya0a+CwC47U9XuGUjX6T/lZfbgJNoYBgymJnRA3W0N+NnmjW7+kzdvAM8u8GnIMhjU712TJ+VweNQlm6fr9dOc8viOhWE9dhDKED1azu1b2rQFg7rORVp4+fYttoCfRweg3zaSlXXzEEwfGnU/0dnsVXbzHI/VclBgvI28jMj1Rj74/fc5bP/ejYAILprt1t25lq6tto4X4Ppv7lW221IMitdb6VAydLhz4dZqRT2xmi8PitjvVt2w9RTAAAPhzmIkPDpoLyB3vemZvN7S4430RIcb6b3UTsghHkPqGrj90gT1KzQz1aUcm0JsVPx2MEoTGC1kK1u0ecw0c/vo+mbKdhCeSOXjUhPTEUxVLJ3/GHDQgDAg3MfdMvKdF2ZdC8AcHwOKdxK/BxWPajfg4LtAsvxeFobp/tQG+O0MkZRlJkkaJ2vrPP3275ALFOCIAiCIAiCIAi9QD6mBEEQBEEQBEEQekHXMr+OWDZGW97XkSlvX+kuLxxPzuErKzlPkldLnGzZgzeJh32Gn8z+UctsGovzckQv28Em2qJk7mu1cjC9nEvBEorvZgkCX0gSKYyt6+gnu6ot7xtsOruXBwsZy1lOk7+AzPrNlmm+SDszLmnivAg1Oi+CnVW7VgdP2drKTqFVzWRuDmaxTsyWpg5LIynK9mbOh7SrgUzexRlsyr/j4zMAAGdO4mANs0O76Pz3pL59X+ncHU4SmZ997f9aPxcA4Cnle/LLix4F0D6wRyROjqMPzecoLdVxNu0/VEFa01wrh93SyhIAQNqv2en0Z189k85vCKeXUVZeFFO/dvAc47wf6+YcWbLxFgDSdAYuW27N+f4ykuwxNPho0VR3+fTTKeDO1iYO9LLpLyTv+87/Pstl2vE75GX5mcGWUy7MoGAKv/Oe4pblp3GbnJBOEpbyCLftqH522cGVTH6V+1Ye75Z9Zv7HAICdfu4/W0K0L/ee1MSW9xluzt0KANgYsZ7pus2WWdL8XE+iHMsOQLE3SuNnveX4b+SC4y35VDycKPsRPh3EYrqfWP23IpIYBMEw4V/Xu8tfP+llAMCsdA5cYnIn+a2cUaYsZgVds2XnRqa7N5rjln3QRHmPxr90lls2ZTONSR41xS0bH+rn5Jt9hPJrl58I13PjXuqD+dY4WaQluedkcm7aIu1+UR7j8WCvDvph+jgAfNg4zl2u13LL4QF+d8rx0diQbwWlMIFCskp7fEk9RixTgiAIgiAIgiAIvaDnlqluMv7SVe6yCYyYj8RQ6t3Ft5/l7rqVdTqnn8zyNFS8/IRu40lifHutcaa7/NCLJwIANl15r1v2PzvI8lHZyjOdRTq0qp0F/TuTaRZrXQtbXzdEhrnLxnF1fQVbsyYX0qzT54dzyOOG4yic6K53eMZ8Roic5MP5QyAARTIrrw5K0RhJ7K1jXuNZqzt2XQ4AyDp3j1uWG6TZ6f/u5qAAjcu5box/aslJpW6ZmfHffSFbVtI/oAAARUkc953YEDFXJbWg83xY2CErq+0IzSF6A1YZ1UGDw3YNOx1AQM/m2eF9K1wn7CTnkOy8UpBYCVsopoYoTPrmhtluWeFjHwEA7jz1NLcs53Wqo6zd3G7St1MAhfgmDrH7RpQCdNRfxtavrVZ33bSJZku9tWxZgQ58Eilga1/dRPq9qc9vcMtW/ncsAODFtRyEZcomGoNS8inl4baULBDNv5rIYjwtrTxhnR0avV4HpLIDoTTEuc2asMgmCJW9/GozWwaSzZonKxMOPtJfJEtwyTfZwmMCl0x9h9VTJaD31ck3c6Cu50Ht1DvpMLeseTI9expHcZsLF1BHD+7j3pi5i8eLQA29ePgq2IoS3VoKIHlKmsZl/HybNZVUKXZ6ACeeejYQJ5oYuSm0g+qozDr3XW1kXV9SP9EtM2kq2uKJnyMFAbYyFVqh04/KJrWbHaLeEGkXwI6Wi19k62J/6cFS764IgiAIgiAIgiAMAeRjShAEQRAEQRAEoRf0m8xPEFKNVvbfRpaWOn27YK1b9s53yJF5evgGt2z9l/4IAHigjvN51Wmz9YwgO1fPSaNM5S/VsGxoWwub66dnkHTte7NedsuM6f7O2y9zy3LwPgDgqYmvuWX/bCTH1Zbi1JdTtcvZplF+GmbsnBnDJ5Aj6oj/x1nKnnniOABA+TKu67994U4AwKLmSW7ZiuEl7vJHVSSrfGzyv9yy3+87FACwt4gdfjOOIqnFR2/OTXbSnV1SSpNMpnRkaLO7bKR/hwdYItGspVdBSyIY8rA0cEmY5FX5lrN/sY+kbWvA7XuoMfk6ls49P2kBAKBlNDujB8Ikp51w2cpOj9NZJsLsR9/v8b72jGbe4sTtVmmV0WRw7sGUlPcZusjVuLieHOznFfH4meuj9hmyAj8Veo2M2u6fiXl33rbiS4zy0nHs8SJZH0kmSxIOPoJ11HYKvDz+zQjQs7itJpi4QxKJamwzy3kDerk3WYuSysuS/F72Nu7dm3SQq7poyNol9Z5XbuApK6jayPdITjnuK/wcyfORbM+fzmOEeTeaHWQpXomP3gtCllTaHlXq4vR7JlAFwBJfO3fthZk0Xjy2c1cPr6jniGVKEARBEARBEAShF4hlSvjUMOanHBb/+jduBAD41u+wtqgBAIy9jbc744UvAAA2Xm1lRh9JVpVDi3m2Y0sOzVgtKStxyxpreZ/leWMAAP5nOFx33oNLALA1yuaskz/nLkdz6TiTlnQ+650SmFlpa4bZhN3fcWRiBJC940rc5ZK4vhd+HpauXPUtAECwmmeSvWGeo3JKaHbxkg3X8UFXUphqJ5r4ewqJVgcn1vlMeqrQVSqFR39EYXZ/N4fnyDxRug/h4byvCtGyY4Wi9VWwZSpQQ/vkb7CCLvybg6QknlhK20ncYAPxZiv4wypqI4FV1oZ6ltgOQa+CepbTbiOmbdtpQsx6yzKr0vzWcuI5uL+TJA2HE7HutbacmmPYvzcUU1psOJz68k0hDvSBKSUAgEgeWwscXS/hAh4PQhWJViZfNYdQV3spBH2sqrrzk0jxNiv0DRn/onHrrvRL3bKINmZMe6/WLXNtPbZV1YwH1vPItcC0dT9wiem39nPG3T+JFTf34SXu8msPJ4ZxN8EyUh3PWxTQ560WDmnu1TXtsXKUbG0pAgC8Xc0padK8VC9ZPh7ftjYUuMvD0+kdrNBSXJj0NaMCNW7ZYcspJUoRWJXQX4hlShAEQRAEQRAEoRfIx5QgCIIgCIIgCEIvUE4n5m6lVCWA7QN3OkOKcY7jFPV0J6nTTpE67Xt6VaeA1GsnSJ32D9L/+x6p075H6rTvkTrte6RO+5791mmnH1OCIAiCIAiCIAhCckTmJwiCIAiCIAiC0AvkY0oQBEEQBEEQBKEXyMeUIAiCIAiCIAhCL5CPKUEQBEEQBEEQhF4gH1OCIAiCIAiCIAi94P8DEBY3reK6sXQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x1080 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# text_labels为分类名\n",
    "text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',\n",
    "               'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']\n",
    "# 提取前十个数据\n",
    "X, y = mnist_train[0:10]\n",
    "# plot images\n",
    "# 以png格式显示图片\n",
    "display.set_matplotlib_formats('png')\n",
    "_, figs = plt.subplots(1, X.shape[0], figsize=(15, 15))\n",
    "for f,x,yi in zip(figs, X,y):\n",
    "    # 3D->2D by removing the last channel dim\n",
    "    f.imshow(x.reshape((28,28)).asnumpy())\n",
    "    ax = f.axes\n",
    "    ax.set_title(text_labels[int(yi)])\n",
    "    ax.title.set_fontsize(14)\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了将图像输入Gulon模型，我们用ToTensor将图像转换为浮点数据，同时对其进行标准化，标准化均值和方差分别为0.13和0.31"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(0.13, 0.31)])\n",
    "mnist_train = mnist_train.transform_first(transformer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了使得训练效果更好，我们将打乱数据，同时设定num_workers=4即四个线程来设置读取数据的进程数，目的是：用多进程加速数据的读取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 256\n",
    "train_data = gluon.data.DataLoader(\n",
    "    mnist_train, batch_size=batch_size, shuffle=True, num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "返回的train_data是一个包含图像和其对应标签的iterable object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(256, 1, 28, 28) (256,)\n"
     ]
    }
   ],
   "source": [
    "# 打印数据\n",
    "for data, label in train_data:\n",
    "    print(data.shape, label.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后我们创建验证集数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist_valid = gluon.data.vision.FashionMNIST(train=False)\n",
    "valid_data = gluon.data.DataLoader(\n",
    "    mnist_valid.transform_first(transformer),\n",
    "    batch_size=batch_size, num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the model  \n",
    "我们建立一个模型，用常用的Xavier法来初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = nn.Sequential()\n",
    "net.add(nn.Conv2D(channels=6, kernel_size=5, activation='relu'),\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        nn.Conv2D(channels=16, kernel_size=3, activation='relu'),\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        nn.Flatten(),\n",
    "        nn.Dense(120, activation=\"relu\"),\n",
    "        nn.Dense(84, activation=\"relu\"),\n",
    "        nn.Dense(10))\n",
    "net.initialize(init=init.Xavier())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义loss\n",
    "softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义训练器，设定学习率为0.1\n",
    "trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 我们创造一个辅助函数来计算精度\n",
    "def acc(output, label):\n",
    "    # output: (batch, num_output) float32 ndarray\n",
    "    # label: (batch, ) int32 ndarray\n",
    "    # asscalar()表示返回值的标量\n",
    "    return (output.argmax(axis=1) == label.astype('float32')).mean().asscalar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: loss 0.730, train acc 0.728, test acc 0.812, in 18.5 sec\n",
      "Epoch 1: loss 0.463, train acc 0.828, test acc 0.856, in 18.6 sec\n"
     ]
    }
   ],
   "source": [
    "# 训练网络2个epochs\n",
    "for epoch in range(2):\n",
    "    train_loss, train_acc, valid_acc = 0., 0., 0.\n",
    "    tic = time.time()\n",
    "    for data, label in train_data:\n",
    "        # forward + backward\n",
    "        with autograd.record():\n",
    "            output = net(data)\n",
    "            loss = softmax_cross_entropy(output, label)\n",
    "        loss.backward()\n",
    "        # update parameters\n",
    "        trainer.step(batch_size)\n",
    "        # calculate training metrics\n",
    "        # 计算loss\n",
    "        train_loss += loss.mean().asscalar()\n",
    "        # 计算acc\n",
    "        train_acc += acc(output, label)\n",
    "    # calculate validation accuracy\n",
    "    for data, label in valid_data:\n",
    "        valid_acc += acc(net(data), label)\n",
    "    print(\"Epoch %d: loss %.3f, train acc %.3f, test acc %.3f, in %.1f sec\" % (\n",
    "            epoch, train_loss/len(train_data), train_acc/len(train_data),\n",
    "            valid_acc/len(valid_data), time.time()-tic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 保存模型参数\n",
    "net.save_parameters('net.params')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 载入模型进行推理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mxnet import nd\n",
    "from mxnet import gluon\n",
    "from mxnet.gluon import nn\n",
    "from mxnet.gluon.data.vision import datasets, transforms\n",
    "from IPython import display\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入网络结构\n",
    "net = nn.Sequential()\n",
    "net.add(nn.Conv2D(channels=6, kernel_size=5, activation='relu'),\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        nn.Conv2D(channels=16, kernel_size=3, activation='relu'),\n",
    "        nn.MaxPool2D(pool_size=2, strides=2),\n",
    "        nn.Flatten(),\n",
    "        nn.Dense(120, activation=\"relu\"),\n",
    "        nn.Dense(84, activation=\"relu\"),\n",
    "        nn.Dense(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入模型\n",
    "net.load_parameters('net.params')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置训练数据的处理信息\n",
    "transformer = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(0.13, 0.31)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 图像预测\n",
    "mnist_valid = datasets.FashionMNIST(train=False)\n",
    "X, y = mnist_valid[:10]\n",
    "preds = []\n",
    "for x in X:\n",
    "    x = transformer(x).expand_dims(axis=0)\n",
    "    pred = net(x).argmax(axis=1)\n",
    "    preds.append(pred.astype('int32').asscalar())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 可视化预测结果\n",
    "_, figs = plt.subplots(1, 10, figsize=(15, 15))\n",
    "text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',\n",
    "               'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']\n",
    "display.set_matplotlib_formats('png')\n",
    "for f,x,yi,pyi in zip(figs, X, y, preds):\n",
    "    f.imshow(x.reshape((28,28)).asnumpy())\n",
    "    ax = f.axes\n",
    "    ax.set_title(text_labels[yi]+'\\n'+text_labels[pyi])\n",
    "    ax.title.set_fontsize(14)\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict with models from Gluon model zoo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mxnet.gluon.model_zoo import vision as models\n",
    "from mxnet.gluon.utils import download\n",
    "from mxnet import image\n",
    "# 从预训练的Gluon模型预测图像\n",
    "net = models.resnet50_v2(pretrained=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获得标签文件\n",
    "url = 'http://data.mxnet.io/models/imagenet/synset.txt'\n",
    "fname = download(url)\n",
    "with open(fname, 'r') as f:\n",
    "    text_labels = [' '.join(l.split()[1:]) for l in f]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机下载狗的文件\n",
    "url = 'https://upload.wikimedia.org/wikipedia/commons/thumb/b/b5/\\\n",
    "Golden_Retriever_medium-to-light-coat.jpg/\\\n",
    "365px-Golden_Retriever_medium-to-light-coat.jpg'\n",
    "fname = download(url)\n",
    "x = image.imread(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将获得的图像变为224大小\n",
    "x = image.resize_short(x, 256)\n",
    "x, _ = image.center_crop(x, (224,224))\n",
    "plt.imshow(x.asnumpy())\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置数据处理方式\n",
    "def transform(data):\n",
    "    data = data.transpose((2,0,1)).expand_dims(axis=0)\n",
    "    rgb_mean = nd.array([0.485, 0.456, 0.406]).reshape((1,3,1,1))\n",
    "    rgb_std = nd.array([0.229, 0.224, 0.225]).reshape((1,3,1,1))\n",
    "    return (data.astype('float32') / 255 - rgb_mean) / rgb_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With prob = 0.98240, it contains golden retriever\n",
      "With prob = 0.00809, it contains English setter\n",
      "With prob = 0.00262, it contains Irish setter, red setter\n",
      "With prob = 0.00223, it contains cocker spaniel, English cocker spaniel, cocker\n",
      "With prob = 0.00177, it contains Labrador retriever\n"
     ]
    }
   ],
   "source": [
    "# 结果分类，并输出top5结果\n",
    "prob = net(transform(x)).softmax()\n",
    "idx = prob.topk(k=5)[0]\n",
    "for i in idx:\n",
    "    i = int(i.asscalar())\n",
    "    print('With prob = %.5f, it contains %s' % (\n",
    "        prob[0,i].asscalar(), text_labels[i]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
